import java.util.*;
import java.lang.String;
public class Main {

    public static void main(String[] args) {
        int a=10,b=4,c=20,d=6;
        int result1= a + b + c + d;
        int result2= a + c % b;
        int result3= a++ * b + c * - -d;
        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);3

    }
    class Solution {

        //KS6 字符串长度最大乘积
//        public boolean findSameElement(String s1, String s2){
//            for(int i : s1.toCharArray()){
//                for(int j : s2.toCharArray()){
//                    if(s1[i] == s2[j]){
//                        return true;
//                    }else{
//                        return false;
//                    }
//                }
//            }
//        }
//        public static void main(String[] args) {
//            Scanner in = new Scanner(System.in);
//            String[] sArr = new String[100];
//            //创建输入字符串数组
//            for(int i = 0;i<;i++){
//                sArr[i] = in.next();
//            }
//
//            int max;
//            //
//            for(int i = 0;i<sArr.length;i++){
//                for(int j = i+1;j<sArr.length;j++){
//                    if(sArr[i] == sArr[j]){
//                        continue;
//                    }else{
//                        max = sArr[i].length()*sArr[j].length();
//                    }
//                    System.out.println(max);
//                }
//            }
//        }

        //newcode OR108 字符串旋转
        public void strReverse(String[] args) {
            Scanner in = new Scanner(System.in);
            String Str = in.nextLine();
            String word1 = Str.split(";")[0];
            String word2 = Str.split(";")[1];

            if(word1.length() != word2.length()){
                //两单词不同必定false
                System.out.println(false);
            }else{
                //如果把一个单词追加一次后包含另一个单词，则是旋转
                System.out.println((word1+word1).contains(word2));
            }
        }
    }

    //newcode OR135 单词缩写
    public void wordAbbreviation(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        for(int i = 0;i<=n;i++){
            String s = in.nextLine();
            if(s.length()<10){
                //单词长度小于等于10直接打印
                System.out.println(s);
            }else{
                //大于十分别打印首位以及中间数
                System.out.print(s.charAt(0));
                System.out.print((s.length()-2));
                System.out.print(s.charAt(s.length() - 1));
                System.out.println();
            }
        }
    }

        //leetcode 128.验证回文串
        public boolean isPalindrome(String s) {
            StringBuffer newStr = new StringBuffer();
            //先把所有字母&数字改为小写放入newStr中
            for(int i=0;i<s.length();i++){
                char ch = s.charAt(i);
                if(Character.isLetterOrDigit(ch)){
                    newStr.append(Character.toLowerCase(ch));
                }
            }
            //得到逆置字符串
            StringBuffer newStr_rev = new StringBuffer(newStr).reverse();
            return newStr.toString().equals(newStr_rev.toString());//判断字符串与逆置的字符串是否相等
        }

        //leetcode 58.最后一个单词的长度
        public int lengthOfLastWord(String s) {
            if(s == null || s.length() == 0)
                return 0;
            int count = 0;
            for(int i = s.length() - 1;i >= 0; i--){
                if(s.charAt(i) == ' '){
                    //如果是最后一个单词尾的空格，跳过本次循环
                    //如果读到最后一个单词前的空格，跳出循环
                    if(count == 0)
                        continue;
                    break;
                }
                count++;
            }
            return count;
        }

        //leetcode 14.最长公共前缀
        //有待研究更多解题方法
        public String longestCommonPrefix(String[] strs) {
            //如果数组本身为空或无元素，直接返回空
            if(strs == null || strs.length==0){
                return "";
            }
            //.length用于字符串加括号，数组不加
            String prefix = strs[0];
            for(int i=1;i<strs.length;i++){
                prefix = longestCoPrefix(prefix, strs[i]);
                //没有共同前缀字符
                if(prefix.length() == 0){
                    break;
                }
            }
            return prefix;
        }

        //计算两个单词的公共前缀
        public String longestCoPrefix(String prefix, String stri) {
            int index = 0;
            int length = Math.min(prefix.length(), stri.length());//得到公共前缀与下一个字符串哪个长度更短
            while(index < length && prefix.charAt(index) == stri.charAt(index)){
                //当index在长度范围内且两个字符串的某个字符相同
                //charAt得到字符串的参数位字符
                index++;
            }
            return prefix.substring(0, index);//返回字符串0-index范围内的子字符串
        }

        //leetcode 13.罗马数字转整数
        public int romanToInt(String s) {
            int sum = 0;//计算总大小
            int preNum = getValue(s.charAt(0));//得到首位罗马数字
            for(int i=1;i<s.length();i++){
                int num = getValue(s.charAt(i));//charAt得到字符串的第几位
                if(preNum < num)
                    sum -= preNum;
                else
                    sum += preNum;
                preNum = num;//走到下一位罗马数字
            }
            sum += preNum;
            return sum;
        }

        public int getValue(char ch) {
            switch (ch) {
                case 'I':
                    return 1;
                case 'V':
                    return 5;
                case 'X':
                    return 10;
                case 'L':
                    return 50;
                case 'C':
                    return 100;
                case 'D':
                    return 500;
                case 'M':
                    return 1000;
                default:
                    return 0;
            }
        }

//    public static void main(String[] args) {
//        String[] strs = {"dog","racecar","car"};
//        System.out.println(strs[1]);
//        System.out.println(strs.length);
//        System.out.println("Hello world!");
//    }
}